diff --git a/back/build.gradle.kts b/back/build.gradle.kts
index 7796c035..bb9030b8 100644
--- a/back/build.gradle.kts
+++ b/back/build.gradle.kts
@@ -43,6 +43,8 @@ dependencies {
 	testImplementation("org.springframework.boot:spring-boot-starter-test")
 	testImplementation("org.springframework.security:spring-security-test")
 	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+
+	implementation ("software.amazon.awssdk:s3:2.25.0")
 }
 
 tasks.withType<Test> {
diff --git a/back/src/main/java/com/back/domain/file/controller/VideoController.java b/back/src/main/java/com/back/domain/file/controller/VideoController.java
new file mode 100644
index 00000000..cdbe3a6e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/controller/VideoController.java
@@ -0,0 +1,33 @@
+package com.back.domain.file.controller;
+
+import com.back.domain.file.service.VideoService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.net.URL;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequiredArgsConstructor
+public class VideoController {
+
+    private final VideoService videoService;
+
+    // 업로드용 Presigned URL
+    @GetMapping("/videos/upload-url")
+    public URL getUploadUrl(@RequestParam String fileName) {
+        return videoService.generateUploadUrl("test-bucket", fileName);
+    }
+
+    // DASH 스트리밍용 URL
+    @GetMapping("/videos/dash-urls")
+    public Map<String, URL> getDashUrls(
+            @RequestParam String mpdFile,
+            @RequestParam List<String> segmentFiles
+    ) {
+        return videoService.generateDashUrls("test-bucket", mpdFile, segmentFiles);
+    }
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/file/entity/Video.java b/back/src/main/java/com/back/domain/file/entity/Video.java
new file mode 100644
index 00000000..d4557dfe
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/entity/Video.java
@@ -0,0 +1,66 @@
+package com.back.domain.file.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+@Getter
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Video extends BaseEntity {
+    @Column(unique = true)
+    private String uuid;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(name = "transcoding_results")
+    private String transcodingResults;
+
+    private String originalPath;
+
+    private Integer views;
+
+    private String originalFileName;
+
+    private Integer duration;
+
+    private Long fileSize;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Video(String uuid, String transcodingResults, String originalPath, Integer views, String originalFileName, Integer duration, Long fileSize) {
+        this.uuid = uuid;
+        this.transcodingResults = transcodingResults;
+        this.originalPath = originalPath;
+        this.views = views;
+        this.originalFileName = originalFileName;
+        this.duration = duration;
+        this.fileSize = fileSize;
+    }
+
+    public static Video create(String uuid, String transcodingResults, String originalPath, String originalFileName, Integer duration, Long fileSize) {
+        if (uuid == null || uuid.isBlank()) {
+            throw new IllegalArgumentException("uuid cannot be null or empty");
+        }
+        if (originalPath == null || originalPath.isBlank()) {
+            throw new IllegalArgumentException("originalPath cannot be null or empty");
+        }
+        if (originalFileName == null || originalFileName.isBlank()) {
+            throw new IllegalArgumentException("originalFileName cannot be null or empty");
+        }
+
+        return Video.builder()
+                .uuid(uuid)
+                .transcodingResults(transcodingResults)
+                .originalPath(originalPath)
+                .views(0)
+                .originalFileName(originalFileName)
+                .duration(duration)
+                .fileSize(fileSize)
+                .build();
+    }
+}
diff --git a/back/src/main/java/com/back/domain/file/repository/VideoRepository.java b/back/src/main/java/com/back/domain/file/repository/VideoRepository.java
new file mode 100644
index 00000000..02e6431e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/repository/VideoRepository.java
@@ -0,0 +1,12 @@
+package com.back.domain.file.repository;
+
+import com.back.domain.file.entity.Video;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface VideoRepository extends JpaRepository<Video, Integer> {
+    Optional<Video> findByUuid(String uuid);
+}
diff --git a/back/src/main/java/com/back/domain/file/service/VideoService.java b/back/src/main/java/com/back/domain/file/service/VideoService.java
new file mode 100644
index 00000000..df65b4c0
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/service/VideoService.java
@@ -0,0 +1,115 @@
+package com.back.domain.file.service;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.file.repository.VideoRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
+import software.amazon.awssdk.services.s3.model.PutObjectRequest;
+import software.amazon.awssdk.services.s3.model.S3Exception;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest;
+
+import java.net.URL;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+public class VideoService {
+    private final VideoRepository videoRepository;
+    private final S3Presigner presigner;
+    private final S3Client s3Client;
+
+    public Video createVideo(String transcodingStatus, String originalPath, String originalFilename, Integer duration, Long fileSize) {
+        String uuid = UUID.randomUUID().toString();
+        Video video = Video.create(uuid, transcodingStatus, originalPath, originalFilename, duration, fileSize);
+        return videoRepository.save(video);
+    }
+
+    public Video getNewsByUuid(String uuid) {
+        return videoRepository.findByUuid(uuid)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 비디오입니다."));
+    }
+
+    //HeadObjectRequest 고려
+    public URL generateUploadUrl(String bucket, String objectKey) {
+        if(!isExist(bucket, objectKey)){
+            throw new RuntimeException("요청한 파일이 존재하지 않습니다: " + objectKey);
+        }
+
+        PutObjectRequest request = PutObjectRequest.builder()
+                .bucket(bucket)
+                .key(objectKey)
+                .build();
+
+        PresignedPutObjectRequest presignedRequest =
+                presigner.presignPutObject(builder -> builder
+                        .signatureDuration(Duration.ofMinutes(30))
+                        .putObjectRequest(request));
+
+        URL url = presignedRequest.url();
+        if (url == null) {
+            throw new RuntimeException("Presigned URL 생성 실패");
+        }
+
+        return url;
+    }
+
+    public URL generateDownloadUrl(String bucket, String objectKey) {
+        if(!isExist(bucket, objectKey)){
+            throw new RuntimeException("요청한 파일이 존재하지 않습니다: " + objectKey);
+        }
+
+        GetObjectRequest request = GetObjectRequest.builder()
+                .bucket(bucket)
+                .key(objectKey)
+                .build();
+
+        PresignedGetObjectRequest presignedRequest =
+                presigner.presignGetObject(builder -> builder
+                        .signatureDuration(Duration.ofHours(1))
+                        .getObjectRequest(request));
+
+        URL url = presignedRequest.url();
+        if (url == null) {
+            throw new RuntimeException("Presigned URL 생성 실패");
+        }
+
+        return url;
+    }
+
+    // DASH용 인덱스 + 세그먼트 URL 발급
+    public Map<String, URL> generateDashUrls(String bucket, String mpdFile, List<String> segmentFiles) {
+        // MPD 파일 URL
+        URL mpdUrl = generateDownloadUrl(bucket, mpdFile);
+
+        // 각 세그먼트 파일 URL
+        Map<String, URL> segmentUrls = segmentFiles.stream()
+                .collect(Collectors.toMap(f -> f, f -> generateDownloadUrl(bucket, f)));
+
+        // MPD 포함 합쳐서 반환
+        segmentUrls.put("mpd", mpdUrl);
+        return segmentUrls;
+    }
+
+    public boolean isExist(String bucket, String objectKey) {
+        try {
+            HeadObjectRequest headRequest = HeadObjectRequest.builder()
+                    .bucket(bucket)
+                    .key(objectKey)
+                    .build();
+
+            s3Client.headObject(headRequest);
+            return true;
+        } catch (S3Exception e) {
+            return false;
+        }
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/controller/CommentController.java b/back/src/main/java/com/back/domain/news/comment/controller/CommentController.java
new file mode 100644
index 00000000..d89ec9cb
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/controller/CommentController.java
@@ -0,0 +1,71 @@
+package com.back.domain.news.comment.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.dto.CommentCreateRequest;
+import com.back.domain.news.comment.dto.CommentResponse;
+import com.back.domain.news.comment.dto.CommentUpdateRequest;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.comment.service.CommentService;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.service.NewsService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/news/{newsId}/comment")
+@RequiredArgsConstructor
+public class CommentController {
+    private final NewsService newsService;
+    private final CommentService commentService;
+    private final Rq rq;
+
+    @GetMapping
+    public RsData<List<CommentResponse>> getComments(@PathVariable Long newsId) {
+        News news = newsService.getNewsById(newsId);
+        List<Comment> comments = commentService.getComments(news);
+        List<CommentResponse> commentResponses = comments.stream()
+                .map(CommentResponse::new)
+                .collect(Collectors.toList());
+        return new RsData<>("200", "댓글 목록 불러오기 완료", commentResponses);
+    }
+
+    @PostMapping
+    public RsData<CommentResponse> createComment(@PathVariable Long newsId, @RequestBody CommentCreateRequest request) {
+        Member member = rq.getActor();
+        if (member == null) {
+            return new RsData<>("401", "로그인이 필요합니다.");
+        }
+        News news = newsService.getNewsById(newsId);
+        Comment comment = commentService.createComment(member, news, request.content());
+        CommentResponse commentResponse = new CommentResponse(comment);
+        return new RsData<>("201", "댓글 생성 완료", commentResponse);
+    }
+
+    @PutMapping("/{commentId}")
+    public RsData<CommentResponse> updateComment(@PathVariable Long newsId, @PathVariable Long commentId, @RequestBody CommentUpdateRequest request) {
+        Member member = rq.getActor();
+        if (member == null) {
+            return new RsData<>("401", "로그인이 필요합니다.");
+        }
+        News news = newsService.getNewsById(newsId);
+        Comment updatedComment = commentService.updateComment(member, news, commentId, request.content());
+        CommentResponse commentResponse = new CommentResponse(updatedComment);
+        return new RsData<>("200", "댓글 수정 완료", commentResponse);
+    }
+
+    @DeleteMapping("/{commentId}")
+    public RsData<Void> deleteComment(@PathVariable Long newsId, @PathVariable Long commentId) {
+        Member member = rq.getActor();
+        if (member == null) {
+            return new RsData<>("401", "로그인이 필요합니다.");
+        }
+        News news = newsService.getNewsById(newsId);
+        commentService.deleteComment(member, news, commentId);
+        return new RsData<>("200", "댓글 삭제 완료");
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/dto/CommentCreateRequest.java b/back/src/main/java/com/back/domain/news/comment/dto/CommentCreateRequest.java
new file mode 100644
index 00000000..dc3ac171
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/dto/CommentCreateRequest.java
@@ -0,0 +1,4 @@
+package com.back.domain.news.comment.dto;
+
+public record CommentCreateRequest(String content) {
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/dto/CommentResponse.java b/back/src/main/java/com/back/domain/news/comment/dto/CommentResponse.java
new file mode 100644
index 00000000..cf852e15
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/dto/CommentResponse.java
@@ -0,0 +1,23 @@
+package com.back.domain.news.comment.dto;
+
+import com.back.domain.news.comment.entity.Comment;
+import lombok.Getter;
+
+import java.time.LocalDateTime;
+
+@Getter
+public class CommentResponse {
+    private final Long id;
+    private final String content;
+    private final String author;
+    private final LocalDateTime createdDate;
+    private final LocalDateTime modifiedDate;
+
+    public CommentResponse(Comment comment) {
+        this.id = comment.getId();
+        this.content = comment.getContent();
+        this.author = comment.getMember().getName();
+        this.createdDate = comment.getCreateDate();
+        this.modifiedDate = comment.getModifyDate();
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/dto/CommentUpdateRequest.java b/back/src/main/java/com/back/domain/news/comment/dto/CommentUpdateRequest.java
new file mode 100644
index 00000000..8b27898c
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/dto/CommentUpdateRequest.java
@@ -0,0 +1,4 @@
+package com.back.domain.news.comment.dto;
+
+public record CommentUpdateRequest(String content) {
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/entity/Comment.java b/back/src/main/java/com/back/domain/news/comment/entity/Comment.java
new file mode 100644
index 00000000..647255d6
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/entity/Comment.java
@@ -0,0 +1,58 @@
+package com.back.domain.news.comment.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.Entity;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Comment extends BaseEntity {
+    @ManyToOne
+    private Member member;
+    @ManyToOne
+    @JoinColumn
+    private News news;
+    private String content;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Comment(Member member, News news, String content) {
+        if (member == null) {
+            throw new IllegalArgumentException("Member cannot be null");
+        }
+        if (news == null) {
+            throw new IllegalArgumentException("News cannot be null");
+        }
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        this.member = member;
+        this.news = news;
+        this.content = content;
+    }
+
+    public static Comment create(Member member, News news, String content) {
+        Comment comment = Comment.builder()
+                .member(member)
+                .news(news)
+                .content(content)
+                .build();
+
+        return comment;
+    }
+
+    public Comment update(String content) {
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        this.content = content;
+        return this;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/repository/CommentRepository.java b/back/src/main/java/com/back/domain/news/comment/repository/CommentRepository.java
new file mode 100644
index 00000000..14909bb0
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/repository/CommentRepository.java
@@ -0,0 +1,13 @@
+package com.back.domain.news.comment.repository;
+
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.news.entity.News;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface CommentRepository extends JpaRepository<Comment, Long> {
+    List<Comment> findByNews(News news);
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/service/CommentService.java b/back/src/main/java/com/back/domain/news/comment/service/CommentService.java
new file mode 100644
index 00000000..9e30c9c3
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/service/CommentService.java
@@ -0,0 +1,55 @@
+package com.back.domain.news.comment.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.comment.repository.CommentRepository;
+import com.back.domain.news.news.entity.News;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class CommentService {
+    private final CommentRepository commentRepository;
+
+    public Comment createComment(Member member, News news, String content) {
+        Comment comment = Comment.create(member, news, content);
+        return commentRepository.save(comment);
+    }
+
+    public List<Comment> getComments(News news) {
+        return commentRepository.findByNews(news);
+    }
+
+    public Optional<Comment> getCommentById(Long commentId) {
+        return commentRepository.findById(commentId);
+    }
+
+    public Comment updateComment(Member member, News news, Long commentId, String content) {
+        Comment comment = getCommentById(commentId).orElseThrow(() -> new IllegalArgumentException("Comment not found"));
+        if (!comment.getMember().equals(member)) {
+            throw new IllegalArgumentException("You do not have permission to update this comment.");
+        }
+        if (!comment.getNews().equals(news)) {
+            throw new IllegalArgumentException("This comment does not belong to the given news.");
+        }
+        comment.update(content);
+        return comment;
+    }
+
+    public void deleteComment(Member member, News news, Long commentId) {
+        Comment comment = getCommentById(commentId).orElseThrow(() -> new IllegalArgumentException("Comment not found"));
+        if (!comment.getMember().equals(member)) {
+            throw new IllegalArgumentException("You do not have permission to delete this comment.");
+        }
+        if (!comment.getNews().equals(news)) {
+            throw new IllegalArgumentException("This comment does not belong to the given news.");
+        }
+        commentRepository.delete(comment);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/like/entity/Like.java b/back/src/main/java/com/back/domain/news/like/entity/Like.java
new file mode 100644
index 00000000..4658afbb
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/like/entity/Like.java
@@ -0,0 +1,49 @@
+package com.back.domain.news.like.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "news_like", uniqueConstraints = {
+        @UniqueConstraint(columnNames = {"member_id", "news_id"})
+})
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Like extends BaseEntity {
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Member member;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private News news;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Like(Member member, News news) {
+        this.member = member;
+        this.news = news;
+    }
+
+    public static Like create(Member member, News news) {
+        if (member == null) {
+            throw new IllegalArgumentException("Member cannot be null");
+        }
+        if (news == null) {
+            throw new IllegalArgumentException("News cannot be null");
+        }
+        Like like = Like.builder()
+                .member(member)
+                .news(news)
+                .build();
+        return like;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/like/repository/LikeRepository.java b/back/src/main/java/com/back/domain/news/like/repository/LikeRepository.java
new file mode 100644
index 00000000..b9735d36
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/like/repository/LikeRepository.java
@@ -0,0 +1,15 @@
+package com.back.domain.news.like.repository;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.entity.Like;
+import com.back.domain.news.news.entity.News;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface LikeRepository extends JpaRepository<Like, Long> {
+    Optional<Like> findByMemberAndNews(Member member, News news);
+    long countByNews(News news);
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/news/like/service/LikeService.java b/back/src/main/java/com/back/domain/news/like/service/LikeService.java
new file mode 100644
index 00000000..ff923bf5
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/like/service/LikeService.java
@@ -0,0 +1,39 @@
+package com.back.domain.news.like.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.entity.Like;
+import com.back.domain.news.like.repository.LikeRepository;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.repository.NewsRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional
+public class LikeService {
+    private final LikeRepository likeRepository;
+    private final NewsRepository newsRepository;
+
+    public Like likeNews(Member member, Long newsId) {
+        News news = newsRepository.findById(newsId)
+                .orElseThrow(() -> new IllegalArgumentException("해당 뉴스를 찾을 수 없습니다."));
+
+        Optional<Like> existingLike = likeRepository.findByMemberAndNews(member, news);
+        if (existingLike.isPresent()) {
+            throw new IllegalStateException("이미 좋아요를 누른 뉴스입니다.");
+        }
+
+        Like like = Like.create(member, news);
+        return likeRepository.save(like);
+    }
+
+    public long getLikeCount(Long newsId) {
+        News news = newsRepository.findById(newsId)
+                .orElseThrow(() -> new IllegalArgumentException("해당 뉴스를 찾을 수 없습니다."));
+        return likeRepository.countByNews(news);
+    }
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/news/news/controller/NewsController.java b/back/src/main/java/com/back/domain/news/news/controller/NewsController.java
new file mode 100644
index 00000000..fa9679c0
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/controller/NewsController.java
@@ -0,0 +1,90 @@
+package com.back.domain.news.news.controller;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.file.service.VideoService;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.service.LikeService;
+import com.back.domain.news.news.dto.*;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.service.NewsService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/news")
+@RequiredArgsConstructor
+public class NewsController {
+    private final NewsService newsService;
+    private final VideoService videoService;
+    private final LikeService likeService;
+    private final Rq rq;
+
+    @PostMapping
+    public RsData<NewsCreateResponse> createNews(@RequestBody NewsCreateRequest request) {
+        Member member = rq.getActor();
+        Video video = videoService.getNewsByUuid(request.videoUuid());
+        News news = newsService.createNews(member, request.title(), video, request.content());
+        NewsCreateResponse response = new NewsCreateResponse(news.getTitle(), news.getVideo().getUuid(), news.getContent(), member.getName());
+        return new RsData<>("201", "뉴스가 생성되었습니다.", response);
+    }
+
+    @GetMapping("{newsId}")
+    public RsData<NewsGetResponse> getNews(@PathVariable Long newsId) {
+        News news = newsService.getNewsById(newsId);
+        NewsGetResponse response = new NewsGetResponse(news);
+        return new RsData<>("200", "뉴스 읽어오기 완료", response);
+    }
+
+    @GetMapping
+    public RsData<List<NewsGetResponse>> getNewsList(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "10") int size) {
+
+        Page<News> newsPage = newsService.getNewsByPage(page, size);
+
+        List<NewsGetResponse> responses = newsPage.getContent().stream()
+                .map(NewsGetResponse::new)
+                .toList();
+
+        return new RsData<>("200", "뉴스 목록 불러오기 완료", responses);
+    }
+
+    @PutMapping("{newsId}/likes")
+    public RsData<NewsLikeResponse> likeNews(@PathVariable Long newsId) {
+        Member member = rq.getActor();
+        try {
+            likeService.likeNews(member, newsId);
+            NewsLikeResponse response = new NewsLikeResponse(member.getId(), newsId, likeService.getLikeCount(newsId));
+            return new RsData<>("200", "뉴스를 좋아합니다.", response);
+        } catch (IllegalArgumentException e) {
+            return new RsData<>("404", e.getMessage(), null);
+        }
+    }
+
+    @PutMapping("{newsId}")
+    public RsData<NewsUpdateResponse> modifyNews(@RequestBody NewsUpdateRequest request) {
+        Member member = rq.getActor();
+        try {
+            News news = newsService.getNewsById(request.newsId());
+            Video video = videoService.getNewsByUuid(request.videoUuid());
+            News updatedNews = newsService.updateNews(member, news, request.title(), video, request.content());
+            NewsUpdateResponse response = new NewsUpdateResponse(updatedNews);
+            return new RsData<>("200", "뉴스가 수정되었습니다.", response);
+        } catch (IllegalArgumentException e) {
+            return new RsData<>("404", e.getMessage(), null);
+        }
+    }
+
+    @DeleteMapping("{newsId}")
+    public RsData<?> deleteNews(@PathVariable Long newsId) {
+        Member member = rq.getActor();
+        News news = newsService.getNewsById(newsId);
+        newsService.deleteNews(member, news);
+        return new RsData<>("200", news.getId()+"번 뉴스가 삭제되었습니다.", null);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsCreateRequest.java b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateRequest.java
new file mode 100644
index 00000000..390da742
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateRequest.java
@@ -0,0 +1,8 @@
+package com.back.domain.news.news.dto;
+
+public record NewsCreateRequest(
+        String title,
+        String videoUuid,
+        String content
+        ) {
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsCreateResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateResponse.java
new file mode 100644
index 00000000..94579e17
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateResponse.java
@@ -0,0 +1,15 @@
+package com.back.domain.news.news.dto;
+
+public record NewsCreateResponse(
+        String title,
+        String videoUrl,
+        String content,
+        String author
+) {
+    public NewsCreateResponse(String title, String videoUrl, String content, String author) {
+        this.title = title;
+        this.videoUrl = videoUrl;
+        this.content = content;
+        this.author = author;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsGetResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsGetResponse.java
new file mode 100644
index 00000000..40a9cd10
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsGetResponse.java
@@ -0,0 +1,25 @@
+package com.back.domain.news.news.dto;
+
+import com.back.domain.news.news.entity.News;
+
+import java.time.LocalDateTime;
+
+public record NewsGetResponse(
+        String title,
+        String videoUuid,
+        String content,
+        String authorId,
+        LocalDateTime createdAt,
+        LocalDateTime updatedAt
+) {
+    public NewsGetResponse(News news) {
+        this(
+                news.getTitle(),
+                news.getVideo().getUuid(),
+                news.getContent(),
+                news.getMember().getName(),
+                news.getCreateDate(),
+                news.getModifyDate()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsLikeResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsLikeResponse.java
new file mode 100644
index 00000000..054de3d1
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsLikeResponse.java
@@ -0,0 +1,9 @@
+package com.back.domain.news.news.dto;
+
+
+public record NewsLikeResponse(
+        Long memberId,
+        Long newsId,
+        Long like
+) {
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateRequest.java b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateRequest.java
new file mode 100644
index 00000000..4b82536c
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateRequest.java
@@ -0,0 +1,8 @@
+package com.back.domain.news.news.dto;
+
+public record NewsUpdateRequest(
+        Long newsId,
+        String title,
+        String content,
+        String videoUuid
+) {}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateResponse.java
new file mode 100644
index 00000000..6a64a67f
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateResponse.java
@@ -0,0 +1,21 @@
+package com.back.domain.news.news.dto;
+
+import com.back.domain.news.news.entity.News;
+
+public record NewsUpdateResponse(
+        Long id,
+        String title,
+        String content,
+        String videoUuid,
+        String authorName
+) {
+    public NewsUpdateResponse(News news) {
+        this(
+                news.getId(),
+                news.getTitle(),
+                news.getContent(),
+                news.getVideo().getUuid(),
+                news.getMember().getName()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/entity/News.java b/back/src/main/java/com/back/domain/news/news/entity/News.java
new file mode 100644
index 00000000..23c8c02f
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/entity/News.java
@@ -0,0 +1,111 @@
+package com.back.domain.news.news.entity;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.like.entity.Like;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class News extends BaseEntity {
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Member member;
+    private String title;
+    @OneToOne
+    private Video video;
+    private String content;
+    @OneToMany(mappedBy = "news", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Comment> comment;
+    @OneToMany(mappedBy = "news", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Like> likes = new ArrayList<>();
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private News(Member member, String title, Video video, String content, List<Comment> comment, List<Like> likes) {
+        this.member = member;
+        this.title = title;
+        this.video = video;
+        this.content = content;
+        this.comment = comment;
+        this.likes = likes;
+    }
+
+    public static News create(Member member, String title, Video video, String content) {
+        if (member == null) {
+            throw new IllegalArgumentException("Member cannot be null");
+        }
+        if (title == null || title.isBlank()) {
+            throw new IllegalArgumentException("Title cannot be null or empty");
+        }
+        if (video == null) {
+            throw new IllegalArgumentException("Video cannot be null");
+        }
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        return News.builder()
+                .member(member)
+                .title(title)
+                .video(video)
+                .content(content)
+                .comment(new ArrayList<>())
+                .likes(new ArrayList<>())
+                .build();
+    }
+
+    public void like(Like like) {
+        if (this.likes.contains(like)) {
+            throw new IllegalStateException("이미 좋아요를 누른 뉴스입니다.");
+        }
+        this.likes.add(like);
+    }
+
+    /**
+     * 좋아요를 취소할 수 있게 해야할까요?
+     */
+    @Deprecated(forRemoval = true)
+    public void unLike(Like like) {
+        if (!this.likes.contains(like)) {
+            throw new IllegalStateException("좋아요를 누르지 않은 뉴스입니다.");
+        }
+        this.likes.remove(like);
+    }
+
+    public void addComment(Comment comment) {
+        if (comment == null) {
+            throw new IllegalArgumentException("Comment cannot be null");
+        }
+        this.comment.add(comment);
+    }
+
+    public void removeComment(Comment comment) {
+        if (comment == null) {
+            throw new IllegalArgumentException("Comment cannot be null");
+        }
+        this.comment.remove(comment);
+    }
+
+    public void update(String title, Video video, String content) {
+        if (title == null || title.isBlank()) {
+            throw new IllegalArgumentException("Title cannot be null or empty");
+        }
+        if (video == null) {
+            throw new IllegalArgumentException("Video cannot be null");
+        }
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        this.title = title;
+        this.video = video;
+        this.content = content;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/repository/NewsRepository.java b/back/src/main/java/com/back/domain/news/news/repository/NewsRepository.java
new file mode 100644
index 00000000..0e948ad9
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/repository/NewsRepository.java
@@ -0,0 +1,9 @@
+package com.back.domain.news.news.repository;
+
+import com.back.domain.news.news.entity.News;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface NewsRepository extends JpaRepository<News, Long> {
+}
diff --git a/back/src/main/java/com/back/domain/news/news/service/NewsService.java b/back/src/main/java/com/back/domain/news/news/service/NewsService.java
new file mode 100644
index 00000000..837ccedf
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/service/NewsService.java
@@ -0,0 +1,48 @@
+package com.back.domain.news.news.service;
+
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.repository.NewsRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class NewsService {
+    private final NewsRepository newsRepository;
+
+    public News createNews(Member member, String title, Video video, String content) {
+        News news = News.create(member, title, video, content);
+        return newsRepository.save(news);
+    }
+
+    public Page<News> getNewsByPage(int page, int size) {
+        Pageable pageable = PageRequest.of(page, size, Sort.by("createDate").descending());
+        return newsRepository.findAll(pageable);
+    }
+
+    public News getNewsById(Long id) {
+        return newsRepository.findById(id).orElseThrow(() -> new IllegalArgumentException("뉴스를 찾을 수 없습니다."));
+    }
+
+    public News updateNews(Member member, News news, String title, Video video, String content) {
+        if (!(member.getRole()== Member.Role.ADMIN)) {
+            throw new SecurityException("수정 권한이 없습니다.");
+        }
+        news.update(title, video, content);
+        return newsRepository.save(news);
+    }
+
+    public void deleteNews(Member member, News news) {
+        if (!(member.getRole()== Member.Role.ADMIN)) {
+            throw new SecurityException("삭제 권한이 없습니다.");
+        }
+        newsRepository.delete(news);
+    }
+}
diff --git a/back/src/main/java/com/back/global/app/S3Config.java b/back/src/main/java/com/back/global/app/S3Config.java
new file mode 100644
index 00000000..285f95fc
--- /dev/null
+++ b/back/src/main/java/com/back/global/app/S3Config.java
@@ -0,0 +1,46 @@
+package com.back.global.app;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+
+import java.net.URI;
+
+@Configuration
+public class S3Config {
+
+    private static final String ACCESS_KEY = "minioadmin"; // FIXME: 실제 키로 교체
+    private static final String SECRET_KEY = "minioadmin"; // FIXME: 실제 비밀키로 교체
+    private static final String ENDPOINT = "http://localhost:9000"; // FIXME: 실제 엔드포인트로 교체
+    private static final Region REGION = Region.AP_SOUTHEAST_1; // FIXME: 실제 리전으로 교체
+
+    @Bean
+    public S3Presigner s3Presigner() {
+        return S3Presigner.builder()
+                .credentialsProvider(
+                        StaticCredentialsProvider.create(
+                                AwsBasicCredentials.create(ACCESS_KEY, SECRET_KEY)
+                        )
+                )
+                .endpointOverride(URI.create(ENDPOINT))
+                .region(REGION)
+                .build();
+    }
+
+    @Bean
+    public S3Client s3Client() {
+        return S3Client.builder()
+                .credentialsProvider(
+                        StaticCredentialsProvider.create(
+                                AwsBasicCredentials.create(ACCESS_KEY, SECRET_KEY)
+                        )
+                )
+                .endpointOverride(URI.create(ENDPOINT))
+                .region(REGION)
+                .build();
+    }
+}
diff --git a/back/src/test/java/com/back/domain/file/entity/VideoTest.java b/back/src/test/java/com/back/domain/file/entity/VideoTest.java
new file mode 100644
index 00000000..b2abf596
--- /dev/null
+++ b/back/src/test/java/com/back/domain/file/entity/VideoTest.java
@@ -0,0 +1,91 @@
+package com.back.domain.file.entity;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class VideoTest {
+
+    @Test
+    @DisplayName("uuid, transcodingResults, originalPath, originalFileName, duration, fileSize로 Video 객체 생성")
+    void videoCreationTest() {
+        String uuid = "sample-uuid";
+        String transcodingResults = "{\"status\":\"done\"}";
+        String originalPath = "/videos/sample.mp4";
+        String originalFileName = "sample.mp4";
+        Integer duration = 120;
+        Long fileSize = 1024L;
+
+        Video video = Video.create(uuid, transcodingResults, originalPath, originalFileName, duration, fileSize);
+
+        assertThat(video).isNotNull();
+        assertThat(video.getUuid()).isEqualTo(uuid);
+        assertThat(video.getTranscodingResults()).isEqualTo(transcodingResults);
+        assertThat(video.getOriginalPath()).isEqualTo(originalPath);
+        assertThat(video.getViews()).isEqualTo(0); // 기본값 확인
+        assertThat(video.getOriginalFileName()).isEqualTo(originalFileName);
+        assertThat(video.getDuration()).isEqualTo(duration);
+        assertThat(video.getFileSize()).isEqualTo(fileSize);
+    }
+
+    @Test
+    @DisplayName("uuid가 null 또는 공백일 경우 예외를 반환한다.")
+    void videoCreationTestWithInvalidUuid() {
+        String transcodingResults = "{}";
+        String originalPath = "/videos/sample.mp4";
+        String originalFileName = "sample.mp4";
+
+        try {
+            Video.create(null, transcodingResults, originalPath, originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Video.create("", transcodingResults, originalPath, originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("originalPath가 null 또는 공백일 경우 예외를 반환한다.")
+    void videoCreationTestWithInvalidOriginalPath() {
+        String uuid = "sample-uuid";
+        String transcodingResults = "{}";
+        String originalFileName = "sample.mp4";
+
+        try {
+            Video.create(uuid, transcodingResults, null, originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Video.create(uuid, transcodingResults, "", originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("originalFileName이 null 또는 공백일 경우 예외를 반환한다.")
+    void videoCreationTestWithInvalidOriginalFileName() {
+        String uuid = "sample-uuid";
+        String transcodingResults = "{}";
+        String originalPath = "/videos/sample.mp4";
+
+        try {
+            Video.create(uuid, transcodingResults, originalPath, null, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Video.create(uuid, transcodingResults, originalPath, "", 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/back/src/test/java/com/back/domain/file/service/VideoServiceTest.java b/back/src/test/java/com/back/domain/file/service/VideoServiceTest.java
new file mode 100644
index 00000000..54ad1e1c
--- /dev/null
+++ b/back/src/test/java/com/back/domain/file/service/VideoServiceTest.java
@@ -0,0 +1,226 @@
+package com.back.domain.file.service;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.file.repository.VideoRepository;
+import com.back.fixture.VideoFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
+import software.amazon.awssdk.services.s3.model.S3Exception;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+
+@ExtendWith(MockitoExtension.class)
+class VideoServiceTest {
+    @Mock
+    private VideoRepository videoRepository;
+    @Mock
+    private S3Presigner presigner;
+    @Mock
+    private S3Client s3Client;
+    @InjectMocks
+    private VideoService videoService;
+
+    @Test
+    @DisplayName("transcodingResults, originalPath, originalFileName, duration, fileSize로 Video 객체 생성")
+    void videoCreationTest() {
+        String uuid = UUID.randomUUID().toString();
+        String transcodingResults = """
+                {
+                  "1080p": {
+                    "file_path": "/path/to/1080p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 150
+                  },
+                  "720p": {
+                    "file_path": "/path/to/720p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 80
+                  },
+                  "480p": {
+                    "file_path": "/path/to/480p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 40
+                  }
+                }
+                """;
+        String originalPath = "/videos/sample.mp4";
+        String originalFileName = "sample.mp4";
+        Integer duration = 120;
+        Long fileSize = 1024L;
+
+        Video video = VideoFixture.create(uuid, transcodingResults, originalPath, originalFileName, duration, fileSize);
+        when(videoRepository.save(any(Video.class))).thenReturn(video);
+
+        Video createdVideo = videoService.createVideo(transcodingResults, originalPath, originalFileName, duration, fileSize);
+        assertThat(createdVideo).isNotNull();
+        assertThat(createdVideo.getUuid()).isEqualTo(uuid);
+        assertThat(createdVideo.getTranscodingResults()).isEqualTo(transcodingResults);
+        assertThat(createdVideo.getOriginalPath()).isEqualTo(originalPath);
+        assertThat(createdVideo.getViews()).isEqualTo(0);
+        assertThat(createdVideo.getOriginalFileName()).isEqualTo(originalFileName);
+        assertThat(createdVideo.getDuration()).isEqualTo(duration);
+        assertThat(createdVideo.getFileSize()).isEqualTo(fileSize);
+    }
+
+    @Test
+    @DisplayName("uuid로 Video 객체 조회")
+    void getNewsByUuidTest() {
+        String uuid = UUID.randomUUID().toString();
+        Video video = VideoFixture.createDefault();
+        when(videoRepository.findByUuid(uuid)).thenReturn(java.util.Optional.of(video));
+
+        Video foundVideo = videoService.getNewsByUuid(uuid);
+        assertThat(foundVideo).isNotNull();
+        assertThat(foundVideo.getUuid()).isEqualTo(video.getUuid());
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 uuid로 Video 객체 조회 시 예외 발생")
+    void getNewsByUuidNotFoundTest() {
+        String uuid = UUID.randomUUID().toString();
+        when(videoRepository.findByUuid(uuid)).thenReturn(java.util.Optional.empty());
+
+        try {
+            videoService.getNewsByUuid(uuid);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+            assertThat(e.getMessage()).isEqualTo("존재하지 않는 비디오입니다.");
+        }
+    }
+
+    @Test
+    @DisplayName("S3 업로드 URL 생성")
+    void generateUploadUrlTest() throws MalformedURLException {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        PresignedPutObjectRequest mocked = mock(PresignedPutObjectRequest.class);
+
+        when(presigner.presignPutObject(any(Consumer.class))).thenReturn(mocked);
+
+        when(mocked.url()).thenReturn(new URL("http://localhost:8080/upload"));
+
+        URL url = videoService.generateUploadUrl(bucket, objectKey);
+
+        assertThat(url).isNotNull();
+        assertThat(url.toString()).isEqualTo("http://localhost:8080/upload");
+    }
+
+    @Test
+    @DisplayName("S3 다운로드 URL 생성")
+    void generateDownloadUrlTest() throws MalformedURLException {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        var mocked = mock(software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest.class);
+
+        when(presigner.presignGetObject(any(Consumer.class))).thenReturn(mocked);
+
+        when(mocked.url()).thenReturn(new URL("http://localhost:8080/download"));
+
+        URL url = videoService.generateDownloadUrl(bucket, objectKey);
+
+        assertThat(url).isNotNull();
+        assertThat(url.toString()).isEqualTo("http://localhost:8080/download");
+    }
+
+    @Test
+    @DisplayName("업로드 URL 요청의 결과가 null일 경우 예외 발생")
+    void generateUploadUrl_PresignRequestNull_Test() {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        when(presigner.presignPutObject(any(Consumer.class))).thenReturn(null);
+
+        try {
+            videoService.generateUploadUrl(bucket, objectKey);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(RuntimeException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("다운로드 URL 요청의 결과가 null일 경우 예외 발생")
+    void generateDownloadUrl_PresignRequestNull_Test() {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        when(presigner.presignGetObject(any(Consumer.class))).thenReturn(null);
+
+        try {
+            videoService.generateDownloadUrl(bucket, objectKey);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(RuntimeException.class);
+        }
+    }
+
+
+    @Test
+    @DisplayName("isExist() - 객체 존재 시 true 반환")
+    void isExist_objectExists_shouldReturnTrue() {
+        String bucket = "test-bucket";
+        String objectKey = "existing.mp4";
+
+        HeadObjectResponse mockResponse = mock(HeadObjectResponse.class);
+        when(s3Client.headObject(any(HeadObjectRequest.class))).thenReturn(mockResponse);
+
+        boolean exist = videoService.isExist(bucket, objectKey);
+
+        assertThat(exist).isTrue();
+    }
+
+    @Test
+    @DisplayName("isExist() - 객체 존재하지 않으면 false 반환")
+    void isExist_objectNotExists_shouldReturnFalse() {
+        String bucket = "test-bucket";
+        String objectKey = "non-existing.mp4";
+
+        doThrow(S3Exception.builder().statusCode(404).build())
+                .when(s3Client).headObject(any(HeadObjectRequest.class));
+
+        boolean exist = videoService.isExist(bucket, objectKey);
+
+        assertThat(exist).isFalse();
+    }
+
+    @Test
+    @DisplayName("generateDashUrls() - MPD와 segment URL 정상 생성")
+    void generateDashUrls_shouldReturnUrls() throws Exception {
+        String bucket = "test-bucket";
+        String mpdFile = "video.mpd";
+        List<String> segmentFiles = List.of("seg1.mp4", "seg2.mp4");
+
+        PresignedGetObjectRequest mockedPresigned = mock(PresignedGetObjectRequest.class);
+        HeadObjectResponse mockResponse = mock(HeadObjectResponse.class);
+
+        when(mockedPresigned.url()).thenReturn(new URL("http://localhost:8080/download"));
+        when(presigner.presignGetObject(any(Consumer.class))).thenReturn(mockedPresigned);
+        when(s3Client.headObject(any(HeadObjectRequest.class))).thenReturn(mockResponse);
+
+        Map<String, URL> urls = videoService.generateDashUrls(bucket, mpdFile, segmentFiles);
+
+        assertThat(urls).isNotNull();
+        assertThat(urls).containsKeys("mpd", "seg1.mp4", "seg2.mp4");
+        urls.values().forEach(url -> assertThat(url.toString()).isEqualTo("http://localhost:8080/download"));
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/news/comment/entity/CommentTest.java b/back/src/test/java/com/back/domain/news/comment/entity/CommentTest.java
new file mode 100644
index 00000000..24706b3a
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/comment/entity/CommentTest.java
@@ -0,0 +1,107 @@
+package com.back.domain.news.comment.entity;
+
+
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class CommentTest {
+    @Test
+    @DisplayName("사용자, 뉴스, 내용으로 댓글 객체 생성")
+    void commentCreationTest() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+        Comment comment = Comment.create(member, news, content);
+
+        assertThat(comment).isNotNull();
+        assertThat(comment.getMember()).isEqualTo(member);
+        assertThat(comment.getNews()).isEqualTo(news);
+        assertThat(comment.getContent()).isEqualTo(content);
+    }
+
+    @Test
+    @DisplayName("멤버가 null인 경우 예외를 반환한다.")
+    void commentCreationTestWithInvalidMember() {
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+
+        try {
+            Comment.create(null, news, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("뉴스가 null인 경우 예외를 반환한다.")
+    void commentCreationTestWithInvalidNews() {
+        Member member = MemberFixture.createDefault();
+        String content = "This is a sample comment content.";
+
+        try {
+            Comment.create(member, null, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void commentCreationTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+
+        try {
+            Comment.create(member, news, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Comment.create(member, news, "");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("댓글 내용을 수정할 수 있다.")
+    void commentUpdateTest() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+        Comment comment = Comment.create(member, news, content);
+
+        String newContent = "This is the updated comment content.";
+        comment.update(newContent);
+
+        assertThat(comment.getContent()).isEqualTo(newContent);
+    }
+
+    @Test
+    @DisplayName("댓글 수정 시 내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void commentUpdateTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+        Comment comment = Comment.create(member, news, content);
+
+        try {
+            comment.update(null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            comment.update("");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/news/comment/service/CommentServiceTest.java b/back/src/test/java/com/back/domain/news/comment/service/CommentServiceTest.java
new file mode 100644
index 00000000..6e1abca5
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/comment/service/CommentServiceTest.java
@@ -0,0 +1,248 @@
+package com.back.domain.news.comment.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.comment.repository.CommentRepository;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.service.NewsService;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class CommentServiceTest {
+
+    @Mock
+    private CommentRepository commentRepository;
+
+    @Mock
+    private NewsService newsService;
+
+    @InjectMocks
+    private CommentService commentService;
+
+    @Test
+    @DisplayName("댓글 생성 성공")
+    void createComment_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "테스트 댓글입니다.";
+        Comment comment = Comment.create(member, news, content);
+
+        when(commentRepository.save(any(Comment.class))).thenReturn(comment);
+
+        // when
+        Comment createdComment = commentService.createComment(member, news, content);
+
+        // then
+        assertThat(createdComment).isNotNull();
+        assertThat(createdComment.getContent()).isEqualTo(content);
+        assertThat(createdComment.getMember()).isEqualTo(member);
+        assertThat(createdComment.getNews()).isEqualTo(news);
+        verify(commentRepository, times(1)).save(any(Comment.class));
+    }
+
+    @Test
+    @DisplayName("뉴스에 대한 댓글 목록 조회 성공")
+    void getComments_Success() {
+        // given
+        News news = NewsFixture.createDefault();
+        Comment comment1 = Comment.create(MemberFixture.createDefault(), news, "댓글1");
+        Comment comment2 = Comment.create(MemberFixture.createDefault(), news, "댓글2");
+        List<Comment> comments = Arrays.asList(comment1, comment2);
+
+        when(commentRepository.findByNews(news)).thenReturn(comments);
+
+        // when
+        List<Comment> foundComments = commentService.getComments(news);
+
+        // then
+        assertThat(foundComments).hasSize(2);
+        assertThat(foundComments).containsExactlyInAnyOrder(comment1, comment2);
+        verify(commentRepository, times(1)).findByNews(news);
+    }
+
+    @Test
+    @DisplayName("댓글 수정 성공")
+    void updateComment_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(member, news, "기존 댓글");
+        Long commentId = 1L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when
+        Comment result = commentService.updateComment(member, news, commentId, updatedContent);
+
+        // then
+        assertThat(result).isNotNull();
+        assertThat(result.getContent()).isEqualTo(updatedContent);
+        verify(commentRepository, times(1)).findById(commentId);
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 댓글 수정 시 예외 발생")
+    void updateComment_CommentNotFound_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long nonExistentCommentId = 999L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(nonExistentCommentId)).thenReturn(Optional.empty());
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.updateComment(member, news, nonExistentCommentId, updatedContent);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("Comment not found");
+        verify(commentRepository, times(1)).findById(nonExistentCommentId);
+    }
+
+    @Test
+    @DisplayName("댓글 작성자가 아닌 사용자가 수정 시 예외 발생")
+    void updateComment_NotAuthor_ThrowsException() {
+        // given
+        Member author = MemberFixture.createDefault();
+        Member otherMember = MemberFixture.create(2L, "other@example.com", "other", "otherpass", Member.Role.MENTEE);
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(author, news, "기존 댓글");
+        Long commentId = 1L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.updateComment(otherMember, news, commentId, updatedContent);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("You do not have permission to update this comment.");
+        verify(commentRepository, times(1)).findById(commentId);
+    }
+
+    @Test
+    @DisplayName("다른 뉴스의 댓글 수정 시 예외 발생")
+    void updateComment_WrongNews_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news1 = NewsFixture.createDefault();
+        News news2 = NewsFixture.create(2L, member, "다른 뉴스");
+        Comment existingComment = Comment.create(member, news1, "기존 댓글");
+        Long commentId = 1L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.updateComment(member, news2, commentId, updatedContent);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("This comment does not belong to the given news.");
+        verify(commentRepository, times(1)).findById(commentId);
+    }
+
+    @Test
+    @DisplayName("댓글 삭제 성공")
+    void deleteComment_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(member, news, "기존 댓글");
+        Long commentId = 1L;
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+        doNothing().when(commentRepository).delete(existingComment);
+
+        // when
+        commentService.deleteComment(member, news, commentId);
+
+        // then
+        verify(commentRepository, times(1)).findById(commentId);
+        verify(commentRepository, times(1)).delete(existingComment);
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 댓글 삭제 시 예외 발생")
+    void deleteComment_CommentNotFound_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long nonExistentCommentId = 999L;
+
+        when(commentRepository.findById(nonExistentCommentId)).thenReturn(Optional.empty());
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.deleteComment(member, news, nonExistentCommentId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("Comment not found");
+        verify(commentRepository, times(1)).findById(nonExistentCommentId);
+        verify(commentRepository, never()).delete(any(Comment.class));
+    }
+
+    @Test
+    @DisplayName("댓글 작성자가 아닌 사용자가 삭제 시 예외 발생")
+    void deleteComment_NotAuthor_ThrowsException() {
+        // given
+        Member author = MemberFixture.createDefault();
+        Member otherMember = MemberFixture.create(2L, "other@example.com", "other", "otherpass", Member.Role.MENTEE);
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(author, news, "기존 댓글");
+        Long commentId = 1L;
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.deleteComment(otherMember, news, commentId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("You do not have permission to delete this comment.");
+        verify(commentRepository, times(1)).findById(commentId);
+        verify(commentRepository, never()).delete(any(Comment.class));
+    }
+
+    @Test
+    @DisplayName("다른 뉴스의 댓글 삭제 시 예외 발생")
+    void deleteComment_WrongNews_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news1 = NewsFixture.createDefault();
+        News news2 = NewsFixture.create(2L, member, "다른 뉴스");
+        Comment existingComment = Comment.create(member, news1, "기존 댓글");
+        Long commentId = 1L;
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.deleteComment(member, news2, commentId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("This comment does not belong to the given news.");
+        verify(commentRepository, times(1)).findById(commentId);
+        verify(commentRepository, never()).delete(any(Comment.class));
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/news/like/entity/LikeTest.java b/back/src/test/java/com/back/domain/news/like/entity/LikeTest.java
new file mode 100644
index 00000000..190599c4
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/like/entity/LikeTest.java
@@ -0,0 +1,59 @@
+package com.back.domain.news.like.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LikeTest {
+
+    @Test
+    @DisplayName("멤버와 뉴스로 좋아요 객체 생성")
+    void createLikeTest() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+
+        // when
+        Like like = Like.create(member, news);
+
+        // then
+        assertThat(like).isNotNull();
+        assertThat(like.getMember()).isEqualTo(member);
+        assertThat(like.getNews()).isEqualTo(news);
+    }
+
+    @Test
+    @DisplayName("멤버가 null일 경우 예외가 발생한다.")
+    void createLikeWithNullMemberTest() {
+        // given
+        News news = NewsFixture.createDefault();
+
+        // when & then
+        try {
+            Like.create(null, news);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+            assertThat(e.getMessage()).isEqualTo("Member cannot be null");
+        }
+    }
+
+    @Test
+    @DisplayName("뉴스가 null일 경우 예외가 발생한다.")
+    void createLikeWithNullNewsTest() {
+        // given
+        Member member = MemberFixture.createDefault();
+
+        // when & then
+        try {
+            Like.create(member, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+            assertThat(e.getMessage()).isEqualTo("News cannot be null");
+        }
+    }
+}
diff --git a/back/src/test/java/com/back/domain/news/like/service/LikeServiceTest.java b/back/src/test/java/com/back/domain/news/like/service/LikeServiceTest.java
new file mode 100644
index 00000000..d846e0ce
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/like/service/LikeServiceTest.java
@@ -0,0 +1,92 @@
+package com.back.domain.news.like.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.entity.Like;
+import com.back.domain.news.like.repository.LikeRepository;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.repository.NewsRepository;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class LikeServiceTest {
+
+    @Mock
+    private LikeRepository likeRepository;
+
+    @Mock
+    private NewsRepository newsRepository;
+
+    @InjectMocks
+    private LikeService likeService;
+
+    @Test
+    @DisplayName("사용자는 뉴스에 '좋아요'를 누를 수 있다.")
+    void likeNews_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long newsId = news.getId();
+
+        when(newsRepository.findById(newsId)).thenReturn(Optional.of(news));
+        when(likeRepository.findByMemberAndNews(member, news)).thenReturn(Optional.empty());
+
+        // when
+        likeService.likeNews(member, newsId);
+
+        // then
+        verify(likeRepository, times(1)).save(any(Like.class));
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 뉴스에 '좋아요'를 누르면 예외가 발생한다.")
+    void likeNews_NewsNotFound_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        Long nonExistentNewsId = 999L;
+
+        when(newsRepository.findById(nonExistentNewsId)).thenReturn(Optional.empty());
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            likeService.likeNews(member, nonExistentNewsId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("해당 뉴스를 찾을 수 없습니다.");
+        verify(likeRepository, never()).save(any(Like.class));
+    }
+
+    @Test
+    @DisplayName("이미 '좋아요'를 누른 뉴스에 다시 '좋아요'를 누르면 예외가 발생한다.")
+    void likeNews_AlreadyLiked_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long newsId = news.getId();
+        Like existingLike = Like.create(member, news);
+
+        when(newsRepository.findById(newsId)).thenReturn(Optional.of(news));
+        when(likeRepository.findByMemberAndNews(member, news)).thenReturn(Optional.of(existingLike));
+
+        // when & then
+        IllegalStateException exception = assertThrows(IllegalStateException.class, () -> {
+            likeService.likeNews(member, newsId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("이미 좋아요를 누른 뉴스입니다.");
+        verify(likeRepository, never()).save(any(Like.class));
+    }
+}
diff --git a/back/src/test/java/com/back/domain/news/news/entity/NewsTest.java b/back/src/test/java/com/back/domain/news/news/entity/NewsTest.java
new file mode 100644
index 00000000..a29e2c10
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/news/entity/NewsTest.java
@@ -0,0 +1,294 @@
+package com.back.domain.news.news.entity;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.like.entity.Like;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.VideoFixture;
+import com.back.domain.member.member.entity.Member;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NewsTest {
+    @Test
+    @DisplayName("제목과 영상,내용으로 뉴스 객체 생성")
+    void newsCreationTestWithTitleAndContent() {
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        Member member = MemberFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        assertThat(news).isNotNull();
+        assertThat(news.getMember()).isEqualTo(member);
+        assertThat(news.getTitle()).isEqualTo(title);
+        assertThat(news.getVideo()).isEqualTo(video);
+        assertThat(news.getContent()).isEqualTo(content);
+        assertThat(news.getComment().size()).isEqualTo(0);
+        assertThat(news.getLikes().size()).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("멤버가 null인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidMember() {
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+
+        try {
+            News.create(null, title, video, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("제목이 null 혹은 공백인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidTitle() {
+        Member member = MemberFixture.createDefault();
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+
+        try {
+            News.create(member, null, video, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            News.create(member, "", video, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("영상이 null인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidVideo() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+
+        try {
+            News.create(member, title, null, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        Video video = VideoFixture.createDefault();
+
+        try {
+            News.create(member, title, video, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            News.create(member, title, video, "");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("사용자는 뉴스에 좋아요를 누를 수 있다.")
+    void likeNewsTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Like like = Like.create(member, news);
+        news.like(like);
+
+        assertThat(news.getLikes().size()).isEqualTo(1);
+        assertThat(news.getLikes()).contains(like);
+    }
+
+    @Test
+    @DisplayName("사용자는 이미 좋아요를 누른 뉴스에 다시 좋아요를 누를 수 없다.")
+    void likeNewsAlreadyLikedTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Like like = Like.create(member, news);
+        news.like(like);
+
+        try {
+            news.like(like);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalStateException.class);
+        }
+
+        assertThat(news.getLikes().size()).isEqualTo(1);
+    }
+
+    @Test
+    @DisplayName("뉴스의 제목, 영상, 내용을 수정할 수 있다.")
+    void updateNewsTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newTitle = "Updated News Title";
+        String newContent = "This is the updated news content.";
+        Video newVideo = VideoFixture.createDefault();
+
+        news.update(newTitle, newVideo, newContent);
+
+        assertThat(news.getTitle()).isEqualTo(newTitle);
+        assertThat(news.getContent()).isEqualTo(newContent);
+        assertThat(news.getVideo()).isEqualTo(newVideo);
+    }
+
+    @Test
+    @DisplayName("업데이트시 제목이 null 혹은 공백인 경우 예외를 반환한다.")
+    void updateNewsTestWithInvalidTitle() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newContent = "This is the updated news content.";
+        Video newVideo = VideoFixture.createDefault();
+
+        try {
+            news.update(null, newVideo, newContent);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            news.update("", newVideo, newContent);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("업데이트시 영상이 null인 경우 예외를 반환한다.")
+    void updateNewsTestWithInvalidVideo() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newTitle = "Updated News Title";
+        String newContent = "This is the updated news content.";
+
+        try {
+            news.update(newTitle, null, newContent);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("업데이트시 내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void updateNewsTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newTitle = "Updated News Title";
+        Video newVideo = VideoFixture.createDefault();
+
+        try {
+            news.update(newTitle, newVideo, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            news.update(newTitle, newVideo, "");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("뉴스에 댓글을 추가할 수 있다.")
+    void addCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Comment comment = Comment.create(member, news, "This is a comment.");
+        news.addComment(comment);
+
+        assertThat(news.getComment().size()).isEqualTo(1);
+        assertThat(news.getComment()).contains(comment);
+    }
+
+    @Test
+    @DisplayName("뉴스에 null 댓글을 추가하려 하면 예외를 반환한다.")
+    void addNullCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        try {
+            news.addComment(null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        assertThat(news.getComment().size()).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("뉴스의 댓글을 제거할 수 있다.")
+    void removeCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Comment comment = Comment.create(member, news, "This is a comment.");
+        news.addComment(comment);
+        assertThat(news.getComment().size()).isEqualTo(1);
+
+        news.removeComment(comment);
+        assertThat(news.getComment().size()).isEqualTo(0);
+    }
+    @Test
+    @DisplayName("뉴스의 null 댓글을 제거하려하면 예외를 반환한다.")
+    void removeNullCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        try {
+            news.removeComment(null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        assertThat(news.getComment().size()).isEqualTo(0);
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/fixture/MemberFixture.java b/back/src/test/java/com/back/fixture/MemberFixture.java
new file mode 100644
index 00000000..73d04064
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/MemberFixture.java
@@ -0,0 +1,69 @@
+package com.back.fixture;
+
+import com.back.domain.member.member.entity.Member;
+
+public class MemberFixture {
+    private String email = "test@example.com";
+    private String password = "password123";
+    private String name = "Test User";
+    private Member.Role role = Member.Role.MENTEE;
+    private Long id = null;
+
+    private static MemberFixture builder() {
+        return new MemberFixture();
+    }
+
+    public static Member createDefault() {
+        return builder().build();
+    }
+
+    public static Member create(Long id, String email, String name, String password, Member.Role role) {
+        return builder()
+                .withId(id)
+                .withEmail(email)
+                .withName(name)
+                .withPassword(password)
+                .withRole(role)
+                .build();
+    }
+
+    public static Member create(String email, String name, String password) {
+        return builder()
+                .withEmail(email)
+                .withName(name)
+                .withPassword(password)
+                .build();
+    }
+
+    public MemberFixture withEmail(String email) {
+        this.email = email;
+        return this;
+    }
+
+    public MemberFixture withPassword(String password) {
+        this.password = password;
+        return this;
+    }
+
+    public MemberFixture withName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public MemberFixture withRole(Member.Role role) {
+        this.role = role;
+        return this;
+    }
+
+    public MemberFixture withId(Long id) {
+        this.id = id;
+        return this;
+    }
+
+    public Member build() {
+        if (id != null) {
+            return new Member(id, email, name);
+        }
+        return new Member(email, password, name, role);
+    }
+}
diff --git a/back/src/test/java/com/back/fixture/NewsFixture.java b/back/src/test/java/com/back/fixture/NewsFixture.java
new file mode 100644
index 00000000..fa60cfab
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/NewsFixture.java
@@ -0,0 +1,76 @@
+package com.back.fixture;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.news.entity.News;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.test.util.ReflectionTestUtils;
+
+public class NewsFixture {
+    private Long id;
+    private Member member = MemberFixture.createDefault();
+    private String title = "Sample News Title";
+    private Video video = VideoFixture.createDefault();
+    private String content = "This is a sample news content.";
+    private List<Comment> comments = new ArrayList<>();
+    private Integer likes = 0;
+
+    private static NewsFixture builder() {
+        return new NewsFixture();
+    }
+
+    public static News createDefault() {
+        return builder().build();
+    }
+
+    public static News create(Long id, Member member, String title) {
+        News news = News.create(member, title, VideoFixture.createDefault(), "content");
+        ReflectionTestUtils.setField(news, "id", id);
+        return news;
+    }
+
+    public NewsFixture withId(Long id) {
+        this.id = id;
+        return this;
+    }
+
+    public NewsFixture withMember(Member member) {
+        this.member = member;
+        return this;
+    }
+
+    public NewsFixture withTitle(String title) {
+        this.title = title;
+        return this;
+    }
+
+    public NewsFixture withVideo(Video video) {
+        this.video = video;
+        return this;
+    }
+
+    public NewsFixture withContent(String content) {
+        this.content = content;
+        return this;
+    }
+
+    public NewsFixture withLikes(Integer likes) {
+        this.likes = likes;
+        return this;
+    }
+
+    public NewsFixture withComments(List<Comment> comments) {
+        this.comments = comments;
+        return this;
+    }
+
+    public News build() {
+        News news = News.create(member, title, video, content);
+        news.getComment().addAll(comments);
+        return news;
+    }
+}
diff --git a/back/src/test/java/com/back/fixture/VideoFixture.java b/back/src/test/java/com/back/fixture/VideoFixture.java
new file mode 100644
index 00000000..d2890aa4
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/VideoFixture.java
@@ -0,0 +1,91 @@
+package com.back.fixture;
+
+import com.back.domain.file.entity.Video;
+
+import java.util.UUID;
+
+public class VideoFixture {
+    private String uuid = UUID.randomUUID().toString();
+    private String transcodingResults = """
+                {
+                  "1080p": {
+                    "file_path": "/path/to/1080p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 150
+                  },
+                  "720p": {
+                    "file_path": "/path/to/720p/video.mpd",
+                    "status": "IN_PROGRESS",
+                    "size_mb": 80
+                  },
+                  "480p": {
+                    "file_path": "/path/to/480p/video.mpd",
+                    "status": "FAILED",
+                    "size_mb": 40
+                  }
+                }
+                """;
+    private String originalPath = "/videos/original.mp4";
+    private String originalFileName = "original.mp4";
+    private Integer duration = 120;
+    private Long fileSize = 1024L * 1024L * 10; // 10MB
+
+    private static VideoFixture builder() {
+        return new VideoFixture();
+    }
+
+    public static Video createDefault() {
+        return builder().build();
+    }
+    public static Video create(String uuid, String transcodingResults, String originalPath, String originalFileName, Integer duration, Long fileSize) {
+        return builder()
+                .withUuid(uuid)
+                .withTranscodingResults(transcodingResults)
+                .withOriginalPath(originalPath)
+                .withOriginalFileName(originalFileName)
+                .withDuration(duration)
+                .withFileSize(fileSize)
+                .build();
+    }
+
+    public VideoFixture withUuid(String uuid) {
+        this.uuid = uuid;
+        return this;
+    }
+
+    public VideoFixture withTranscodingResults(String transcodingResults) {
+        this.transcodingResults = transcodingResults;
+        return this;
+    }
+
+    public VideoFixture withOriginalPath(String originalPath) {
+        this.originalPath = originalPath;
+        return this;
+    }
+
+    public VideoFixture withOriginalFileName(String originalFileName) {
+        this.originalFileName = originalFileName;
+        return this;
+    }
+
+    public VideoFixture withDuration(Integer duration) {
+        this.duration = duration;
+        return this;
+    }
+
+    public VideoFixture withFileSize(Long fileSize) {
+        this.fileSize = fileSize;
+        return this;
+    }
+
+    public Video build() {
+        return Video.create(
+                uuid,
+                transcodingResults,
+                originalPath,
+                originalFileName,
+                duration,
+                fileSize
+        );
+    }
+}
\ No newline at end of file
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 00000000..80a2439a
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,18 @@
+version: "3.8"
+
+services:
+  minio:
+    image: quay.io/minio/minio:latest
+    container_name: minio
+    ports:
+      - "9000:9000"   # S3 API
+      - "9001:9001"   # Web Console
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    volumes:
+      - minio-data:/data
+    command: server /data --console-address ":9001"
+
+volumes:
+  minio-data: